home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus 2002 #11 / Amiga Plus CD - 2002 - No. 11.iso / Tools / AmigaSystem / Scalos / GuiGFXLib / src / guigfx_lib.c < prev    next >
Encoding:
C/C++ Source or Header  |  2002-10-28  |  11.4 KB  |  545 lines
  1.  
  2. #include "guigfx_global.h"
  3.  
  4. #ifdef __MORPHOS__
  5. PIC *MakePictureA_GATE(void);
  6. PIC *LoadPictureA_GATE(void);
  7. PIC *ReadPictureA_GATE(void);
  8. PIC *ClonePictureA_GATE(void);
  9. void DeletePicture_GATE(void);
  10. BOOL UpdatePicture_GATE(void);
  11. COLORHANDLE *AddPictureA_GATE(void);
  12. COLORHANDLE *AddPaletteA_GATE(void);
  13. COLORHANDLE *AddPixelArrayA_GATE(void);
  14. void RemColorHandle_GATE(void);
  15. PSM *CreatePenShareMapA_GATE(void);
  16. void DeletePenShareMap_GATE(void);
  17. DRAWHANDLE *ObtainDrawHandleA_GATE(void);
  18. void ReleaseDrawHandle_GATE(void);
  19. BOOL DrawPictureA_GATE(void);
  20. BOOL MapPaletteA_GATE(void);
  21. LONG MapPenA_GATE(void);
  22. struct BitMap *CreatePictureBitMapA_GATE(void);
  23. ULONG DoPictureMethodA_GATE(void);
  24. ULONG GetPictureAttrsA_GATE(void);
  25. ULONG LockPictureA_GATE(void);
  26. void UnLockPicture_GATE(void);
  27. BOOL IsPictureA_GATE(void);
  28. DIRECTDRAWHANDLE *CreateDirectDrawHandleA_GATE(void);
  29. void DeleteDirectDrawHandle_GATE(void);
  30. BOOL DirectDrawTrueColorA_GATE(void);
  31. BOOL CreatePictureMaskA_GATE(void);
  32. #endif
  33.  
  34. /*****************************************************************************/
  35.  
  36. /* Reserved library-function and dummy entrypoint */
  37. LONG LibNull()
  38. {
  39.     return(NULL);
  40. }
  41.  
  42. /*****************************************************************************/
  43.  
  44. //#define SysBase GuiGFXBase->ExecBase
  45. struct ExecBase *SysBase = NULL;
  46. struct GuiGFXBase *GuiGFXBase = NULL;
  47.  
  48. /*****************************************************************************/
  49.  
  50. ULONG LibVectors[] =
  51. {
  52. #ifdef __MORPHOS__
  53.     FUNCARRAY_32BIT_NATIVE,
  54. #endif
  55.     (ULONG) &LibOpen,
  56.     (ULONG) &LibClose,
  57. #ifdef __MORPHOS__
  58.     (ULONG) &LIBExpunge,
  59. #else
  60.     (ULONG) &LibExpunge,
  61. #endif
  62.     (ULONG) &LibNull,
  63.  
  64. #ifdef __MORPHOS__
  65.     (ULONG) &MakePictureA_GATE,
  66.     (ULONG) &LoadPictureA_GATE,
  67.     (ULONG) &ReadPictureA_GATE,
  68.     (ULONG) &ClonePictureA_GATE,
  69.     (ULONG) &DeletePicture_GATE,
  70.     (ULONG) &UpdatePicture_GATE,
  71.     (ULONG) &AddPictureA_GATE,
  72.     (ULONG) &AddPaletteA_GATE,
  73.     (ULONG) &AddPixelArrayA_GATE,
  74.     (ULONG) &RemColorHandle_GATE,
  75.     (ULONG) &CreatePenShareMapA_GATE,
  76.     (ULONG) &DeletePenShareMap_GATE,
  77.     (ULONG) &ObtainDrawHandleA_GATE,
  78.     (ULONG) &ReleaseDrawHandle_GATE,
  79.     (ULONG) &DrawPictureA_GATE,
  80.     (ULONG) &MapPaletteA_GATE,
  81.     (ULONG) &MapPenA_GATE,
  82.     (ULONG) &CreatePictureBitMapA_GATE,
  83.     (ULONG) &DoPictureMethodA_GATE,
  84.     (ULONG) &GetPictureAttrsA_GATE,
  85.     (ULONG) &LockPictureA_GATE,
  86.     (ULONG) &UnLockPicture_GATE,
  87.     (ULONG) &IsPictureA_GATE,
  88.     (ULONG) &CreateDirectDrawHandleA_GATE,
  89.     (ULONG) &DeleteDirectDrawHandle_GATE,
  90.     (ULONG) &DirectDrawTrueColorA_GATE,
  91.     (ULONG) &CreatePictureMaskA_GATE,
  92. #else
  93.     (ULONG) &MakePictureA,
  94.     (ULONG) &LoadPictureA,
  95.     (ULONG) &ReadPictureA,
  96.     (ULONG) &ClonePictureA,
  97.     (ULONG) &DeletePicture,
  98.     (ULONG) &UpdatePicture,
  99.     (ULONG) &AddPictureA,
  100.     (ULONG) &AddPaletteA,
  101.     (ULONG) &AddPixelArrayA,
  102.     (ULONG) &RemColorHandle,
  103.     (ULONG) &CreatePenShareMapA,
  104.     (ULONG) &DeletePenShareMap,
  105.     (ULONG) &ObtainDrawHandleA,
  106.     (ULONG) &ReleaseDrawHandle,
  107.     (ULONG) &DrawPictureA,
  108.     (ULONG) &MapPaletteA,
  109.     (ULONG) &MapPenA,
  110.     (ULONG) &CreatePictureBitMapA,
  111.     (ULONG) &DoPictureMethodA,
  112.     (ULONG) &GetPictureAttrsA,
  113.     (ULONG) &LockPictureA,
  114.     (ULONG) &UnLockPicture,
  115.     (ULONG) &IsPictureA,
  116.     (ULONG) &CreateDirectDrawHandleA,
  117.     (ULONG) &DeleteDirectDrawHandle,
  118.     (ULONG) &DirectDrawTrueColorA,
  119.     (ULONG) &CreatePictureMaskA,
  120. #endif
  121.  
  122.     0xFFFFFFFF
  123. };
  124.  
  125. struct LibInitStruct
  126. {
  127.     ULONG    LibSize;
  128.     void    *FuncTable;
  129.     void    *DataTable;
  130.     void    (*InitFunc)(void);
  131. };
  132.  
  133. struct LibInitStruct LibInitStruct = {
  134.     sizeof(struct GuiGFXBase),
  135.     LibVectors,
  136.     NULL,
  137.     (void (*)(void)) &LibInit
  138. };
  139.  
  140. static const char LibVersion[] = "$VER: " LIBNAME " " LIBVER " " LIBDATE LIBTYPE;
  141.  
  142. static const struct Resident RomTag = {
  143.     RTC_MATCHWORD,
  144.     &RomTag,
  145.     &RomTag + 1,
  146. #ifdef __MORPHOS__
  147.     RTF_PPC | RTF_AUTOINIT,
  148. #else
  149.     RTF_AUTOINIT,
  150. #endif
  151.     VERSION,
  152.     NT_LIBRARY,
  153.     0,
  154.     LIBNAME,
  155.     &LibVersion[6],
  156.     &LibInitStruct
  157. };
  158.  
  159. #ifdef __MORPHOS__
  160. ULONG __amigappc__ = 1;
  161. #endif
  162.  
  163. /*****************************************************************************/
  164.  
  165. struct Library * LIBENT LibInit(
  166.         /* DO NOT change the order of these arguments! */
  167.         REG(d0) struct Library *LibBase,
  168.         REG(a0) BPTR Segment,
  169.         REG(a6) struct ExecBase *ExecBase)
  170. {
  171.     SysBase = ExecBase;
  172.     GuiGFXBase = (struct GuiGFXBase *) LibBase;
  173.  
  174. #ifndef __MORPHOS__
  175.     if(ExecBase->LibNode.lib_Version < 39 ||
  176.         !(ExecBase->AttnFlags & AFF_68020))
  177.     {
  178.         return(NULL);
  179.     }
  180. #endif
  181.  
  182.     GuiGFXBase->LibNode.lib_Revision = REVISION;
  183.     GuiGFXBase->LibSegment = Segment;
  184.     GuiGFXBase->ExecBase = ExecBase;
  185.  
  186.     InitSemaphore(&GuiGFXBase->LockSemaphore);
  187.  
  188.     return(LibBase);
  189. }
  190.  
  191. /*****************************************************************************/
  192.  
  193. struct Library * LIBENT LibOpen(
  194. #ifdef __MORPHOS__
  195.     void)
  196. {
  197.     struct Library *LibBase = (struct Library *)REG_A6;
  198. #else
  199.     REG(a6) struct Library *LibBase)
  200. {
  201. #endif
  202.     DB(kprintf("guigfx opencount when entering LibOpen: %ld\n", LibBase->lib_OpenCnt));
  203.  
  204.     GuiGFXBase->LibNode.lib_Flags &= ~LIBF_DELEXP;
  205.     GuiGFXBase->LibNode.lib_OpenCnt++;
  206.  
  207.     ObtainSemaphore(&GuiGFXBase->LockSemaphore);
  208.  
  209.     if(GuiGFXBase->LibNode.lib_OpenCnt == 1)
  210.     {
  211.         if(!GGFX_Init())
  212.         {
  213.             GGFX_Exit();
  214.  
  215.             GuiGFXBase->LibNode.lib_OpenCnt--;
  216.  
  217.             LibBase = NULL;
  218.         }
  219.     }
  220.  
  221.     ReleaseSemaphore(&GuiGFXBase->LockSemaphore);
  222.  
  223.     return(LibBase);
  224. }
  225.  
  226. /*****************************************************************************/
  227.  
  228. #ifdef __MORPHOS__
  229. BPTR LIBExpunge(void)
  230. {
  231.     struct Library *LibBase = (struct Library *)REG_A6;
  232.  
  233.     return LibExpunge(LibBase);
  234. }
  235. #endif
  236.  
  237. BPTR LIBENT LibExpunge(
  238.     REG(a6) struct Library *LibBase)
  239. {
  240.     DB(kprintf("guigfx opencount when entering LibExpunge: %ld\n", LibBase->lib_OpenCnt));
  241.  
  242.     if(GuiGFXBase->LibNode.lib_OpenCnt == 0 && 
  243.         GuiGFXBase->LibSegment != NULL)
  244.     {
  245.         BPTR TempSegment = GuiGFXBase->LibSegment;
  246.  
  247.         Remove((struct Node *)GuiGFXBase);
  248.  
  249.         FreeMem((APTR)((ULONG)(GuiGFXBase) - (ULONG)(GuiGFXBase->LibNode.lib_NegSize)),
  250.             GuiGFXBase->LibNode.lib_NegSize + GuiGFXBase->LibNode.lib_PosSize);
  251.  
  252.         GuiGFXBase = NULL;
  253.  
  254.         return(TempSegment);
  255.     }
  256.     else
  257.     {
  258.         GuiGFXBase->LibNode.lib_Flags |= LIBF_DELEXP;
  259.  
  260.         return(NULL);
  261.     }
  262. }
  263.  
  264. /*****************************************************************************/
  265.  
  266. BPTR LIBENT LibClose(
  267. #ifdef __MORPHOS__
  268.     void)
  269. {
  270.     struct Library *LibBase = (struct Library *)REG_A6;
  271. #else
  272.     REG(a6) struct Library *LibBase)
  273. {
  274. #endif
  275.     DB(kprintf("guigfx opencount when entering LibClose: %ld\n", LibBase->lib_OpenCnt));
  276.  
  277.     ObtainSemaphore(&GuiGFXBase->LockSemaphore);
  278.  
  279.     if (GuiGFXBase->LibNode.lib_OpenCnt > 0)
  280.     {
  281.         if (!(--GuiGFXBase->LibNode.lib_OpenCnt))
  282.             GGFX_Exit();
  283.     }
  284.  
  285.     ReleaseSemaphore(&GuiGFXBase->LockSemaphore);
  286.  
  287.     if(GuiGFXBase->LibNode.lib_OpenCnt == 0 && 
  288.         (GuiGFXBase->LibNode.lib_Flags & LIBF_DELEXP))
  289.     {
  290.         DB(kprintf("!>>closing down guigfx.library.\n"));
  291.         return(LibExpunge(LibBase));
  292.     }
  293.     else
  294.     {
  295.         return(NULL);
  296.     }
  297. }
  298.  
  299. /*****************************************************************************/
  300.  
  301. #ifdef __MORPHOS__
  302. PIC *MakePictureA_GATE(void)
  303. {
  304.     APTR array = (APTR)REG_A0;
  305.     UWORD width = (UWORD)REG_D0;
  306.     UWORD height = (UWORD)REG_D1;
  307.     TAGLIST tags = (TAGLIST)REG_A1;
  308.  
  309.     return MakePictureA(array, width, height, tags);
  310. }
  311.  
  312. PIC *LoadPictureA_GATE(void)
  313. {
  314.     STRPTR filename = (STRPTR)REG_A0;
  315.     TAGLIST tags = (TAGLIST)REG_A1;
  316.  
  317.     return LoadPictureA(filename, tags);
  318. }
  319.  
  320. PIC *ReadPictureA_GATE(void)
  321. {
  322.     struct RastPort *rp = (struct RastPort *)REG_A0;
  323.     struct ColorMap *cm = (struct ColorMap *)REG_A1;
  324.     UWORD x = (UWORD)REG_D0;
  325.     UWORD y = (UWORD)REG_D1;
  326.     UWORD width = (UWORD)REG_D2;
  327.     UWORD height = (UWORD)REG_D3;
  328.     TAGLIST tags = (TAGLIST)REG_A2;
  329.  
  330.     return ReadPictureA(rp, cm, x, y, width, height, tags);
  331. }
  332.  
  333. PIC *ClonePictureA_GATE(void)
  334. {
  335.     PIC *pic = (PIC *)REG_A0;
  336.     TAGLIST tags = (TAGLIST)REG_A1;
  337.  
  338.     return ClonePictureA(pic, tags);
  339. }
  340.  
  341. void DeletePicture_GATE(void)
  342. {
  343.     PIC *pic = (PIC *)REG_A0;
  344.  
  345.     DeletePicture(pic);
  346. }
  347.  
  348. BOOL UpdatePicture_GATE(void)
  349. {
  350.     PIC *pic = (PIC *)REG_A0;
  351.  
  352.     return UpdatePicture(pic);
  353. }
  354.  
  355. COLORHANDLE *AddPictureA_GATE(void)
  356. {
  357.     PSM *psm = (PSM *)REG_A0;
  358.     PIC *pic = (PIC *)REG_A1;
  359.     TAGLIST tags = (TAGLIST)REG_A2;
  360.  
  361.     return AddPictureA(psm, pic, tags);
  362. }
  363.  
  364. COLORHANDLE *AddPaletteA_GATE(void)
  365. {
  366.     PSM *psm = (PSM *)REG_A0;
  367.     PALETTE palette = (PALETTE)REG_A1;
  368.     TAGLIST tags = (TAGLIST)REG_A2;
  369.  
  370.     return AddPaletteA(psm, palette, tags);
  371. }
  372.  
  373. COLORHANDLE *AddPixelArrayA_GATE(void)
  374. {
  375.     PSM *psm = (PSM *)REG_A0;
  376.     APTR array = (APTR)REG_A1;
  377.     UWORD width = (UWORD)REG_D0;
  378.     UWORD height = (UWORD)REG_D1;
  379.     TAGLIST tags = (TAGLIST)REG_A2;
  380.  
  381.     return AddPixelArrayA(psm, array, width, height, tags);
  382. }
  383.  
  384. void RemColorHandle_GATE(void)
  385. {
  386.     COLORHANDLE *colorhandle = (COLORHANDLE *)REG_A0;
  387.  
  388.     RemColorHandle(colorhandle);
  389. }
  390.  
  391. PSM *CreatePenShareMapA_GATE(void)
  392. {
  393.     TAGLIST tags = (TAGLIST)REG_A0;
  394.  
  395.     return CreatePenShareMapA(tags);
  396. }
  397.  
  398. void DeletePenShareMap_GATE(void)
  399. {
  400.     PSM *psm = (PSM *)REG_A0;
  401.  
  402.     DeletePenShareMap(psm);
  403. }
  404.  
  405. DRAWHANDLE *ObtainDrawHandleA_GATE(void)
  406. {
  407.     PSM *psm = (PSM *)REG_A0;
  408.     struct RastPort *rp = (struct RastPort *)REG_A1;
  409.     struct ColorMap *cm = (struct ColorMap *)REG_A2;
  410.     TAGLIST tags = (TAGLIST)REG_A3;
  411.  
  412.     return ObtainDrawHandleA(psm, rp, cm, tags);
  413. }
  414.  
  415. void ReleaseDrawHandle_GATE(void)
  416. {
  417.     DRAWHANDLE *drawhandle = (DRAWHANDLE *)REG_A0;
  418.  
  419.     ReleaseDrawHandle(drawhandle);
  420. }
  421.  
  422. BOOL DrawPictureA_GATE(void)
  423. {
  424.     DRAWHANDLE *drawhandle = (DRAWHANDLE *)REG_A0;
  425.     PIC *pic = (PIC *)REG_A1;
  426.     UWORD x = (UWORD)REG_D0;
  427.     UWORD y = (UWORD)REG_D1;
  428.     TAGLIST tags = (TAGLIST)REG_A2;
  429.  
  430.     return DrawPictureA(drawhandle, pic, x, y, tags);
  431. }
  432.  
  433. BOOL MapPaletteA_GATE(void)
  434. {
  435.     DRAWHANDLE *drawhandle = (DRAWHANDLE *)REG_A0;
  436.     PALETTE palette = (PALETTE)REG_A1;
  437.     UBYTE *pentab = (UBYTE *)REG_A2;
  438.     TAGLIST tags = (TAGLIST)REG_A3;
  439.  
  440.     return MapPaletteA(drawhandle, palette, pentab, tags);
  441. }
  442.  
  443. LONG MapPenA_GATE(void)
  444. {
  445.     DRAWHANDLE *drawhandle = (DRAWHANDLE *)REG_A0;
  446.     ULONG rgb = (ULONG)REG_D0;
  447.     TAGLIST tags = (TAGLIST)REG_A1;
  448.  
  449.     return MapPenA(drawhandle, rgb, tags);
  450. }
  451.  
  452. struct BitMap *CreatePictureBitMapA_GATE(void)
  453. {
  454.     DRAWHANDLE *drawhandle = (DRAWHANDLE *)REG_A0;
  455.     PIC *pic = (PIC *)REG_A1;
  456.     TAGLIST tags = (TAGLIST)REG_A2;
  457.  
  458.     return CreatePictureBitMapA(drawhandle, pic, tags);
  459. }
  460.  
  461. ULONG DoPictureMethodA_GATE(void)
  462. {
  463.     APTR pic = (APTR)REG_A0;
  464.     ULONG method = (ULONG)REG_D0;
  465.     ULONG *arguments = (ULONG *)REG_A1;
  466.  
  467.     return DoPictureMethodA(pic, method, arguments);
  468. }
  469.  
  470. ULONG GetPictureAttrsA_GATE(void)
  471. {
  472.     PIC *pic = (PIC *)REG_A0;
  473.     TAGLIST tags = (TAGLIST)REG_A1;
  474.  
  475.     return GetPictureAttrsA(pic, tags);
  476. }
  477.  
  478. ULONG LockPictureA_GATE(void)
  479. {
  480.     PIC *pic = (PIC *)REG_A0;
  481.     ULONG mode = (ULONG)REG_D0;
  482.     ULONG *arguments = (ULONG *)REG_A1;
  483.  
  484.     return LockPictureA(pic, mode, arguments);
  485. }
  486.  
  487. void UnLockPicture_GATE(void)
  488. {
  489.     PIC *pic = (PIC *)REG_A0;
  490.     ULONG mode = (ULONG)REG_D0;
  491.  
  492.     UnLockPicture(pic, mode);
  493. }
  494.  
  495. BOOL IsPictureA_GATE(void)
  496. {
  497.     char *filename = (char *)REG_A0;
  498.     TAGLIST tags = (TAGLIST)REG_A1;
  499.  
  500.     return IsPictureA(filename, tags);
  501. }
  502.  
  503. DIRECTDRAWHANDLE *CreateDirectDrawHandleA_GATE(void)
  504. {
  505.     DRAWHANDLE *drawhandle = (DRAWHANDLE *)REG_A0;
  506.     UWORD sw = (UWORD)REG_D0;
  507.     UWORD sh = (UWORD)REG_D1;
  508.     UWORD dw = (UWORD)REG_D2;
  509.     UWORD dh = (UWORD)REG_D3;
  510.     TAGLIST tags = (TAGLIST)REG_A1;
  511.  
  512.     return CreateDirectDrawHandleA(drawhandle, sw, sh, dw, dh, tags);
  513. }
  514.  
  515. void DeleteDirectDrawHandle_GATE(void)
  516. {
  517.     DIRECTDRAWHANDLE *ddh = (DIRECTDRAWHANDLE *)REG_A0;
  518.  
  519.     DeleteDirectDrawHandle(ddh);
  520. }
  521.  
  522. BOOL DirectDrawTrueColorA_GATE(void)
  523. {
  524.     DIRECTDRAWHANDLE *ddh = (DIRECTDRAWHANDLE *)REG_A0;
  525.     ULONG *array = (ULONG *)REG_A1;
  526.     UWORD x = (UWORD)REG_D0;
  527.     UWORD y = (UWORD)REG_D1;
  528.     TAGLIST tags = (TAGLIST)REG_A2;
  529.  
  530.     return DirectDrawTrueColorA(ddh, array, x, y, tags);
  531. }
  532.  
  533. BOOL CreatePictureMaskA_GATE(void)
  534. {
  535.     PIC *pic = (PIC *)REG_A0;
  536.     UBYTE *array = (UBYTE *)REG_A1;
  537.     UWORD arraywidth = (UWORD)REG_D0;
  538.     TAGLIST tags = (TAGLIST)REG_A2;
  539.  
  540.     return CreatePictureMaskA(pic, array, arraywidth, tags);
  541. }
  542.  
  543. #endif
  544.  
  545.